Verteilungstransparenz bei der objektorientierten Spezifikation verteilter Applikationen

Verteilte Applikationen werden heute zunehmend verteilungstransparent programmiert. Wenn man schon bei der Programmierung weitgehend von verteilungsbedingten technischen Details abstrahieren kann, erhofft man sich dies natürlich erst recht für die Spezifikation. Bei genauerem Hinsehen zeigt sich allerdings, daß manche Transparenzdefizite der Implementierung schon bei der Spezifikation berücksichtigt werden müssen, und zwar auch bei sorgfältiger objektorientierter Strukturierung. Die vorliegende Arbeit erläutert die Problematik anhand einer in Object-Z formulierten Beispielapplikation und zeigt auf, was beim Entwurf zu beachten ist

Concurrency Annotations and Reusability

Widespread acceptance of concurrent object-oriented programming in the field can only be expected if smooth integration with sequential programming is achieved. This means that a common language base has to be used, where the concurrent syntax differs as little as possible from the sequential one but is associated with a "natural" concurrent semantics that makes library support for concurrency superfluous. In addition, not only should sequential classes be reusable in a concurrent context, but concurrent classes should also be reusable in a sequential context. It is suggested that concurrency annotations be inserted into otherwise sequential code. They are ignored by a sequential compiler, but a compiler for the extended concurrent language will recognize them and generate the appropriate concurrent code. The concurrent version of the language supports active and concurrent objects and favours a declarative approach to synchronization and locking which solves typical concurrency problems in an easier and more readable way than previous approaches. Concurrency annotations are introduced using Eiffel as the sequential base

Object-oriented program animation using JAN

Concept and design of the program animation system JAN are described. JAN visualizes the execution of a Java program by dynamically unfolding an object diagram and an interaction diagram. Several features distinguish JAN from existing program visualization systems and visual debuggers. Annotations in the program code can be used to control the animation by selecting the relevant events and customizing the visual appearance. In addition, the user can interactively steer the animation in various ways. JAN is an integrated visualization system which includes an elaborate graphical user interface, a preprocessor for annotated Java source code and a visualization engine that runs in a separate Java virtual machine. The design of the system is described in detail

Automatic Mediation between Incompatible Component Interaction Styles

Incompatibility of component interaction styles is identified as a major obstacle to interoperability when using off-the-shelf components or dealing with legacy software in compositional development. It is argued that a language for defining abstract interfaces -- AID -- can serve as a basis for accommodating heterogeneous interaction styles. AID is independent of any concrete style, such as invocation, pipe-and-filter, event-based or others. An AID text just specifies elementary input and output events which happen at the boundary of a component

Concurrency Annotations for Reusable Concurrent Software

Concurrency annotations are inserted into otherwise sequential object-oriented code, inducing a concurrent semantics that is very close to the original sequential semantics. This facilitates integrated engineering of sequential and concurrent software, in particular reuse of code across the boundary between concurrency and sequentiality. Concurrency annotations also blend well with inheritance, giving an additional boost to reusability . The annotations approach to reusable concurrent software is presented using Eiffel as the sequential base for a concurrent language called CEiffel. Thus: Eiffel + annotations =CEiffel

JAN – Java Animation for Program Understanding Abstract

JAN is a system for animated execution of Java programs. Its application area is program understanding rather than debugging. To this end, the animation can be customized, both by annotating the code with visualization directives and by interactively adapting the visual appearance to the user’s personal taste. Object diagrams and sequence diagrams are supported. Scalability is achieved by recognizing object composition: object aggregates are displayed in a nested fashion and mechanisms for collapsing and exploding aggregates are provided. JAN has been applied to itself, producing an animation of its visualization backend. 1